package com.byf.cart.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.byf.cart.domain.Cart;
import com.byf.cart.domain.CartItem;
import com.byf.cart.domain.dto.AddCartDTO;
import com.byf.cart.mapper.CartItemMapper;
import com.byf.cart.mapper.CartMapper;
import com.byf.cart.service.CartService;
import com.byf.cart.vo.CartItemVo;
import com.byf.cart.vo.CartVo;
import com.byf.common.core.domain.Result;
import com.byf.common.core.utils.StringUtils;
import com.byf.common.redis.service.RedisService;
import com.byf.common.security.utils.SecurityUtils;
import com.byf.product.domain.PmsSkuInfo;
import com.byf.product.RemotePmsSkuInfoService;
import com.byf.product.domain.PmsSkuSaleAttrValue;
import com.byf.system.domain.SysUser;
import com.byf.system.model.LoginUser;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;

@Service
public class CartServiceImpl implements CartService {

    @Autowired
    private RedisService redisService;

    @Autowired
    private CartMapper cartMapper;

    @Autowired
    private RemotePmsSkuInfoService pmsSkuInfoService;

    @Autowired
    private CartItemMapper cartItemMapper;

    @Override
    public void addCart(AddCartDTO addCartDto) {
        //获取登录人信息
        LoginUser loginUser = SecurityUtils.getLoginUser();
        SysUser user = loginUser.getSysUser();
        Cart cart2 = new Cart();
        cart2.setUserId(user.getUserId());
        List<Cart> carts1 = cartMapper.selectCartList(cart2);
        Result<PmsSkuInfo> result2 = pmsSkuInfoService.getInfo(addCartDto.getSkuId());
        PmsSkuInfo pmsSkuInfo1 = result2.getData();
        ArrayList<Long> merchantsIds = new ArrayList<>();
        if (!CollectionUtils.isEmpty(carts1)){
            for (Cart cart3 : carts1) {
                merchantsIds.add(cart3.getMerchantsId());
            }
        }

        //判断redis中是否有当前登录人的购物车信息
        if (!redisService.hasKey("CART:" + user.getUserId()) || !merchantsIds.contains(pmsSkuInfo1.getMerchantsId()) ) {
            //没有则添加一条购物车及购物车详情信息
            Cart cart = new Cart();
            cart.setUserId(user.getUserId());
            CartItemVo cartItemVo = new CartItemVo();
            //远程调用根据skuId查询sku商品信息方法
            Result<PmsSkuInfo> result = pmsSkuInfoService.getInfo(addCartDto.getSkuId());
            PmsSkuInfo pmsSkuInfo = result.getData();
            cart.setMerchantsId(pmsSkuInfo.getMerchantsId());
            cartMapper.insertCart(cart);
            //将查询到的sku商品信息copy到购物车详情模型中
            BeanUtils.copyProperties(pmsSkuInfo, cartItemVo);
            cartItemVo.setCount(addCartDto.getCount());
            cartItemVo.setCheckedStatus(1);
            cartItemVo.setCartId(cart.getId());
            PmsSkuSaleAttrValue pmsSkuSaleAttrValue = new PmsSkuSaleAttrValue();
            pmsSkuSaleAttrValue.setSkuId(addCartDto.getSkuId());
            ArrayList<String> attrValues = new ArrayList<>();
            //根据skuId查询sku商品属性
            Result<List<PmsSkuSaleAttrValue>> result1 = pmsSkuInfoService.selectPmsSkuSaleAttrValueList(pmsSkuSaleAttrValue);
            List<PmsSkuSaleAttrValue> list = result1.getData();
            if (!CollectionUtils.isEmpty(list)) {
                for (PmsSkuSaleAttrValue skuSaleAttrValue : list) {
                    attrValues.add(skuSaleAttrValue.getAttrValue());
                }
            }
            cartItemVo.setAttrValues(StringUtils.join(attrValues, ","));
            redisService.setCacheMapValue("CART:" + user.getUserId(), String.valueOf(addCartDto.getSkuId()), cartItemVo);
        } else {
            //有责继续判断该购物车中是否有该商品详情信息
            Object cartItemVoObj = redisService.getCacheMapValue("CART:" + user.getUserId(), String.valueOf(addCartDto.getSkuId()));
            String cartItemVoJson = JSONObject.toJSONString(cartItemVoObj);
            CartItemVo cartItemVo = JSONObject.parseObject(cartItemVoJson, CartItemVo.class);
            if (cartItemVo != null) {
                //如果该购物车中有该商品详情信息则数量加一
                cartItemVo.setCount(cartItemVo.getCount() + addCartDto.getCount());
                redisService.setCacheMapValue("CART:" + user.getUserId(), String.valueOf(addCartDto.getSkuId()), cartItemVo);
            } else {
                //没有则新添一条购物车详情信息
                //远程调用根据skuId查询sku商品信息方法
                Result<PmsSkuInfo> result = pmsSkuInfoService.getInfo(addCartDto.getSkuId());
                PmsSkuInfo pmsSkuInfo = result.getData();
                CartItemVo itemVo = new CartItemVo();
                //将查询到的sku商品信息copy到购物车详情模型中
                BeanUtils.copyProperties(pmsSkuInfo, itemVo);
                itemVo.setCount(addCartDto.getCount());
                itemVo.setCheckedStatus(1);
                Cart cart = new Cart();
                cart.setUserId(user.getUserId());
                //根据skuid查询一条购物车信息
                List<Cart> carts = cartMapper.selectCartList(cart);
                if (!CollectionUtils.isEmpty(carts)) {
                    for (Cart cart1 : carts) {
                        if (Objects.equals(cart1.getMerchantsId(), pmsSkuInfo.getMerchantsId())) {
                            itemVo.setCartId(cart1.getId());
                        }
                    }
                }
                PmsSkuSaleAttrValue pmsSkuSaleAttrValue = new PmsSkuSaleAttrValue();
                pmsSkuSaleAttrValue.setSkuId(addCartDto.getSkuId());
                ArrayList<String> attrValues = new ArrayList<>();
                //根据skuId和attrId查询sku商品属性
                Result<List<PmsSkuSaleAttrValue>> result1 = pmsSkuInfoService.selectPmsSkuSaleAttrValueList(pmsSkuSaleAttrValue);
                List<PmsSkuSaleAttrValue> list = result1.getData();
                if (!CollectionUtils.isEmpty(list)) {
                    for (PmsSkuSaleAttrValue skuSaleAttrValue : list) {
                        attrValues.add(skuSaleAttrValue.getAttrValue());
                    }
                }
                itemVo.setAttrValues(StringUtils.join(attrValues, ","));
                redisService.setCacheMapValue("CART:" + user.getUserId(), String.valueOf(addCartDto.getSkuId()), itemVo);
            }
        }
    }

    /**
     * 删除购物车详情信息
     *
     * @param skuId
     */
    @Override
    public void delCart(Long skuId) {
        //获取登录人信息
        LoginUser loginUser = SecurityUtils.getLoginUser();
        SysUser user = loginUser.getSysUser();
        redisService.deleteCacheMapValue("CART:" + user.getUserId(), String.valueOf(skuId));
    }

    @Override
    public List<CartVo> getCartList() {
        //获取登录人信息
        LoginUser loginUser = SecurityUtils.getLoginUser();
        SysUser user = loginUser.getSysUser();
        List<CartVo> cartVos = new ArrayList<>();

        //根据userId查询购物车信息
        Cart cart = new Cart();
        cart.setUserId(user.getUserId());
        List<Cart> carts = cartMapper.selectCartList(cart);
        if (!CollectionUtils.isEmpty(carts)){

            for (Cart cart1 : carts) {
                ArrayList<CartItemVo> cartItemVos = new ArrayList<>();
                CartVo cartVo = new CartVo();
                BeanUtils.copyProperties(cart1,cartVo);
                Collection<String> cartKeys = redisService.keys("CART:" + user.getUserId());

                for (String cartKey : cartKeys) {
                    Map<String, Object> cartItemMap = redisService.getCacheMap(cartKey);
                    Collection<Object> cartItems = cartItemMap.values();
                    for (Object cartItem : cartItems) {
                        String cartItemJson = JSON.toJSONString(cartItem);
//                        String cartItemJson = JSONObject.toJSONString(cartItem);
                        CartItemVo cartItemVo = JSONObject.parseObject(cartItemJson, CartItemVo.class);
                        if (Objects.equals(cart1.getId(), cartItemVo.getCartId())){
                            cartItemVos.add(cartItemVo);
                        }
                    }
                }
                if (CollectionUtils.isEmpty(cartItemVos)) {
                    CartItem cartItem = new CartItem();
                    List<CartItem> cartItems = cartItemMapper.selectCartItemList(cartItem);
                    for (CartItem item : cartItems) {
                        //没有则新添一条购物车详情信息
                        //远程调用根据skuId查询sku商品信息方法
                        Result<PmsSkuInfo> result = pmsSkuInfoService.getInfo(item.getSkuId());
                        PmsSkuInfo pmsSkuInfo = result.getData();
                        CartItemVo itemVo = new CartItemVo();
                        //将查询到的sku商品信息copy到购物车详情模型中
                        BeanUtils.copyProperties(pmsSkuInfo, itemVo);
                        itemVo.setCount(item.getCount());
                        itemVo.setCartId(item.getCartId());
                        itemVo.setCheckedStatus(item.getCheckedStatus());
                        PmsSkuSaleAttrValue pmsSkuSaleAttrValue = new PmsSkuSaleAttrValue();
                        pmsSkuSaleAttrValue.setSkuId(item.getSkuId());
                        Result<List<PmsSkuSaleAttrValue>> result1 = pmsSkuInfoService.selectPmsSkuSaleAttrValueList(pmsSkuSaleAttrValue);
                        List<PmsSkuSaleAttrValue> list = result1.getData();
                        ArrayList<String> attrValues = new ArrayList<>();
                        if (!CollectionUtils.isEmpty(list)) {
                            for (PmsSkuSaleAttrValue skuSaleAttrValue : list) {
                                attrValues.add(skuSaleAttrValue.getAttrValue());
                            }
                        }
                        itemVo.setAttrValues(StringUtils.join(attrValues, ","));
                        cartItemVos.add(itemVo);
                        redisService.setCacheMapValue("CART:" + user.getUserId(),JSONObject.toJSONString(item.getSkuId()),itemVo);
                    }
                }
                cartVo.setCartItemVos(cartItemVos);
                cartVos.add(cartVo);
            }

        }

        return cartVos;
    }

    @Override
    public void updCartItemCount(AddCartDTO addCartDTO) {
        //获取登录人信息
        LoginUser loginUser = SecurityUtils.getLoginUser();
        SysUser user = loginUser.getSysUser();
        Object cartItemVoObj = redisService.getCacheMapValue("CART:" + user.getUserId(), String.valueOf(addCartDTO.getSkuId()));
        String cartItemVoJson = JSONObject.toJSONString(cartItemVoObj);
        CartItemVo cartItemVo = JSONObject.parseObject(cartItemVoJson, CartItemVo.class);
        cartItemVo.setCount(addCartDTO.getCount());
        redisService.setCacheMapValue("CART:" + user.getUserId(), String.valueOf(addCartDTO.getSkuId()),cartItemVo);
    }


    //    @Transactional
//    @Override
//    public void addCart(AddCartDTO addCartDto) {
//        //获取登录人信息
////        LoginUser loginUser = SecurityUtils.ge tLoginUser();
////        SysUser user = loginUser.getSysUser();
//
//        //判断redis中是否有当前登录人的购物车信息
//        if (!redisService.hasKey("CART_MAP"+":"+1L)){
//            //没有则插入购物车对象以及购物车详情
//            CartVo addCartVo = new CartVo();
//            addCartVo.setUserId(1L);
//            addCartVo.setCreateDatetime(new Date());
//            Cart addCart = new Cart();
//            addCart.setUserId(1L);
//            cartMapper.insertCart(addCart);
//            addCartVo.setId(addCart.getId());
//            HashMap<Long, CartItem> map = new HashMap<>();
//            CartItem cartItem = new CartItem();
//            BeanUtils.copyProperties(addCartDto,cartItem);
//            cartItem.setCheckedStatus(1);
//            cartItem.setCartId(addCart.getId());
//            map.put(addCartDto.getSkuId(),cartItem);
//            addCartVo.setCartItemMap(map);
//            HashMap<String, CartVo> cartMap = new HashMap<>();
//            cartMap.put(String.valueOf(1),addCartVo);
//            redisService.setCacheMap("CART_MAP"+":"+1L,cartMap);
//        }else {
////            Map<String, HashMap<String,CartVo>> cacheMap = redisService.getCacheMap("CART_MAP" + ":" + 1L);
//            //有则只添加购物车详情（添加时判断该商品是否已经存在）
//            Object cartVoObj = redisService.redisTemplate.opsForHash().get("CART_MAP" + ":" + 1L, "1");
//            String cartJson = JSONObject.toJSONString(cartVoObj);
//            CartVo cartVo = JSONObject.parseObject(cartJson, CartVo.class);
//            HashMap<Long, CartItem> cartItemMap = cartVo.getCartItemMap();
//            CartItem cartItem = cartItemMap.get(addCartDto.getSkuId());
//            if (cartItem!=null){
//                //存在则修改商品数量
//                cartItem.setCount(cartItem.getCount()+1);
//                cartItemMap.put(addCartDto.getSkuId(), cartItem);
//                cartVo.setCartItemMap(cartItemMap);
//                HashMap<String, CartVo> cartMap = new HashMap<>();
//                cartMap.put(String.valueOf(1),cartVo);
//                redisService.setCacheMap("CART_MAP"+":"+1L,cartMap);
//            }else {
//                //不存在则在该购物车中添加一条购物车详情
//                CartItem cartItem1 = new CartItem();
//                cartItem1.setCheckedStatus(1);
//                cartItem1.setCartId(cartVo.getId());
//                BeanUtils.copyProperties(addCartDto,cartItem1);
//                cartItemMap.put(addCartDto.getSkuId(), cartItem1);
//                cartVo.setCartItemMap(cartItemMap);
//                HashMap<String, CartVo> cartMap = new HashMap<>();
//                cartMap.put(String.valueOf(1),cartVo);
//                redisService.setCacheMap("CART_MAP"+":"+1L,cartMap);
//            }
//        }
//
//    }
}

